home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / encodings / punycode.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-11-11  |  7.9 KB  |  261 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. ''' Codec for the Punicode encoding, as specified in RFC 3492
  5.  
  6. Written by Martin v. L\xf6wis.
  7. '''
  8. import codecs
  9.  
  10. def segregate(str):
  11.     '''3.1 Basic code point segregation'''
  12.     base = []
  13.     extended = { }
  14.     for c in str:
  15.         if ord(c) < 128:
  16.             base.append(c)
  17.             continue
  18.         extended[c] = 1
  19.     
  20.     extended = extended.keys()
  21.     extended.sort()
  22.     return (''.join(base).encode('ascii'), extended)
  23.  
  24.  
  25. def selective_len(str, max):
  26.     '''Return the length of str, considering only characters below max.'''
  27.     res = 0
  28.     for c in str:
  29.         if ord(c) < max:
  30.             res += 1
  31.             continue
  32.     
  33.     return res
  34.  
  35.  
  36. def selective_find(str, char, index, pos):
  37.     '''Return a pair (index, pos), indicating the next occurrence of
  38.     char in str. index is the position of the character considering
  39.     only ordinals up to and including char, and pos is the position in
  40.     the full string. index/pos is the starting position in the full
  41.     string.'''
  42.     l = len(str)
  43.     while None:
  44.         pos += 1
  45.         if pos == l:
  46.             return (-1, -1)
  47.         c = str[pos]
  48.         if c == char:
  49.             return (index + 1, pos)
  50.         if c < char:
  51.             index += 1
  52.             continue
  53.         continue
  54.         return None
  55.  
  56.  
  57. def insertion_unsort(str, extended):
  58.     '''3.2 Insertion unsort coding'''
  59.     oldchar = 128
  60.     result = []
  61.     oldindex = -1
  62.     for c in extended:
  63.         index = pos = -1
  64.         char = ord(c)
  65.         curlen = selective_len(str, char)
  66.         delta = (curlen + 1) * (char - oldchar)
  67.         while None:
  68.             (index, pos) = selective_find(str, c, index, pos)
  69.             if index == -1:
  70.                 break
  71.             
  72.             delta += index - oldindex
  73.             oldindex = index
  74.             delta = 0
  75.             continue
  76.             oldchar = char
  77.     return result
  78.  
  79.  
  80. def T(j, bias):
  81.     res = 36 * (j + 1) - bias
  82.     if res < 1:
  83.         return 1
  84.     if res > 26:
  85.         return 26
  86.     return res
  87.  
  88. digits = 'abcdefghijklmnopqrstuvwxyz0123456789'
  89.  
  90. def generate_generalized_integer(N, bias):
  91.     '''3.3 Generalized variable-length integers'''
  92.     result = []
  93.     j = 0
  94.     while None:
  95.         t = T(j, bias)
  96.         if N < t:
  97.             result.append(digits[N])
  98.             return result
  99.         N = (N - t) // (36 - t)
  100.         j += 1
  101.         continue
  102.         return None
  103.  
  104.  
  105. def adapt(delta, first, numchars):
  106.     if first:
  107.         delta //= 700
  108.     else:
  109.         delta //= 2
  110.     delta += delta // numchars
  111.     divisions = 0
  112.     while delta > 455:
  113.         delta = delta // 35
  114.         divisions += 36
  115.     bias = divisions + 36 * delta // (delta + 38)
  116.     return bias
  117.  
  118.  
  119. def generate_integers(baselen, deltas):
  120.     '''3.4 Bias adaptation'''
  121.     result = []
  122.     bias = 72
  123.     for points, delta in enumerate(deltas):
  124.         s = generate_generalized_integer(delta, bias)
  125.         result.extend(s)
  126.         bias = adapt(delta, points == 0, baselen + points + 1)
  127.     
  128.     return ''.join(result)
  129.  
  130.  
  131. def punycode_encode(text):
  132.     (base, extended) = segregate(text)
  133.     base = base.encode('ascii')
  134.     deltas = insertion_unsort(text, extended)
  135.     extended = generate_integers(len(base), deltas)
  136.     if base:
  137.         return base + '-' + extended
  138.     return extended
  139.  
  140.  
  141. def decode_generalized_number(extended, extpos, bias, errors):
  142.     '''3.3 Generalized variable-length integers'''
  143.     result = 0
  144.     w = 1
  145.     j = 0
  146.     while None:
  147.         
  148.         try:
  149.             char = ord(extended[extpos])
  150.         except IndexError:
  151.             if errors == 'strict':
  152.                 raise UnicodeError, 'incomplete punicode string'
  153.             errors == 'strict'
  154.             return (extpos + 1, None)
  155.  
  156.         extpos += 1
  157.         if char <= char:
  158.             pass
  159.         elif char <= 90:
  160.             digit = char - 65
  161.         elif char <= char:
  162.             pass
  163.         elif char <= 57:
  164.             digit = char - 22
  165.         elif errors == 'strict':
  166.             raise UnicodeError("Invalid extended code point '%s'" % extended[extpos])
  167.         else:
  168.             return (extpos, None)
  169.         t = 65(j, bias)
  170.         result += digit * w
  171.         if digit < t:
  172.             return (extpos, result)
  173.         w = w * (36 - t)
  174.         j += 1
  175.         continue
  176.         return None
  177.  
  178.  
  179. def insertion_sort(base, extended, errors):
  180.     '''3.2 Insertion unsort coding'''
  181.     char = 128
  182.     pos = -1
  183.     bias = 72
  184.     extpos = 0
  185.     while extpos < len(extended):
  186.         (newpos, delta) = decode_generalized_number(extended, extpos, bias, errors)
  187.         if delta is None:
  188.             return base
  189.         pos += delta + 1
  190.         char += pos // (len(base) + 1)
  191.         if char > 1114111:
  192.             if errors == 'strict':
  193.                 raise UnicodeError, 'Invalid character U+%x' % char
  194.             errors == 'strict'
  195.             char = ord('?')
  196.         
  197.         pos = pos % (len(base) + 1)
  198.         base = base[:pos] + unichr(char) + base[pos:]
  199.         bias = adapt(delta, extpos == 0, len(base))
  200.         extpos = newpos
  201.     return base
  202.  
  203.  
  204. def punycode_decode(text, errors):
  205.     pos = text.rfind('-')
  206.     if pos == -1:
  207.         base = ''
  208.         extended = text
  209.     else:
  210.         base = text[:pos]
  211.         extended = text[pos + 1:]
  212.     base = unicode(base, 'ascii', errors)
  213.     extended = extended.upper()
  214.     return insertion_sort(base, extended, errors)
  215.  
  216.  
  217. class Codec(codecs.Codec):
  218.     
  219.     def encode(self, input, errors = 'strict'):
  220.         res = punycode_encode(input)
  221.         return (res, len(input))
  222.  
  223.     
  224.     def decode(self, input, errors = 'strict'):
  225.         if errors not in ('strict', 'replace', 'ignore'):
  226.             raise UnicodeError, 'Unsupported error handling ' + errors
  227.         errors not in ('strict', 'replace', 'ignore')
  228.         res = punycode_decode(input, errors)
  229.         return (res, len(input))
  230.  
  231.  
  232.  
  233. class IncrementalEncoder(codecs.IncrementalEncoder):
  234.     
  235.     def encode(self, input, final = False):
  236.         return punycode_encode(input)
  237.  
  238.  
  239.  
  240. class IncrementalDecoder(codecs.IncrementalDecoder):
  241.     
  242.     def decode(self, input, final = False):
  243.         if self.errors not in ('strict', 'replace', 'ignore'):
  244.             raise UnicodeError, 'Unsupported error handling ' + self.errors
  245.         self.errors not in ('strict', 'replace', 'ignore')
  246.         return punycode_decode(input, self.errors)
  247.  
  248.  
  249.  
  250. class StreamWriter(Codec, codecs.StreamWriter):
  251.     pass
  252.  
  253.  
  254. class StreamReader(Codec, codecs.StreamReader):
  255.     pass
  256.  
  257.  
  258. def getregentry():
  259.     return codecs.CodecInfo(name = 'punycode', encode = Codec().encode, decode = Codec().decode, incrementalencoder = IncrementalEncoder, incrementaldecoder = IncrementalDecoder, streamwriter = StreamWriter, streamreader = StreamReader)
  260.  
  261.